package org.example.rzfx.controller;

import cn.dev33.satoken.annotation.SaCheckRole;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.example.rzfx.dto.Result;
import org.example.rzfx.entity.LogParseRule;
import org.example.rzfx.mapper.LogParseRuleMapper;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;

/**
 * 日志解析规则控制器
 */
@RestController
@RequestMapping("/api/parse-rule")
@CrossOrigin
public class LogParseRuleController {
    
    @Resource
    private LogParseRuleMapper logParseRuleMapper;
    
    /**
     * 查询所有解析规则
     */
    @GetMapping("/list")
    public Result<?> listRules() {
        return Result.success(logParseRuleMapper.selectList(null));
    }
    
    /**
     * 根据系统类型查询解析规则
     */
    @GetMapping("/system/{systemType}")
    public Result<?> getRulesBySystem(@PathVariable String systemType) {
        LambdaQueryWrapper<LogParseRule> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(LogParseRule::getSystemType, systemType)
               .eq(LogParseRule::getEnabled, 1);
        return Result.success(logParseRuleMapper.selectList(wrapper));
    }
    
    /**
     * 分页查询解析规则
     */
    @GetMapping("/page")
    public Result<?> pageRules(@RequestParam(defaultValue = "1") Integer pageNum,
                               @RequestParam(defaultValue = "20") Integer pageSize) {
        Page<LogParseRule> page = new Page<>(pageNum, pageSize);
        return Result.success(logParseRuleMapper.selectPage(page, null));
    }
    
    /**
     * 获取解析规则详情
     */
    @GetMapping("/{id}")
    public Result<LogParseRule> getRuleDetail(@PathVariable Long id) {
        LogParseRule rule = logParseRuleMapper.selectById(id);
        if (rule == null) {
            return Result.error("解析规则不存在");
        }
        return Result.success(rule);
    }
    
    /**
     * 创建解析规则（管理员权限）
     */
    @PostMapping("/create")
    @SaCheckRole("1")
    public Result<Void> createRule(@Valid @RequestBody LogParseRule rule) {
        logParseRuleMapper.insert(rule);
        return Result.success("创建成功", null);
    }
    
    /**
     * 更新解析规则（管理员权限）
     */
    @PutMapping("/update")
    @SaCheckRole("1")
    public Result<Void> updateRule(@Valid @RequestBody LogParseRule rule) {
        if (logParseRuleMapper.selectById(rule.getId()) == null) {
            return Result.error("解析规则不存在");
        }
        logParseRuleMapper.updateById(rule);
        return Result.success("更新成功", null);
    }
    
    /**
     * 删除解析规则（管理员权限）
     */
    @DeleteMapping("/{id}")
    @SaCheckRole("1")
    public Result<Void> deleteRule(@PathVariable Long id) {
        logParseRuleMapper.deleteById(id);
        return Result.success("删除成功", null);
    }
    
    /**
     * 启用/禁用解析规则（管理员权限）
     */
    @PutMapping("/status/{id}/{enabled}")
    @SaCheckRole("1")
    public Result<Void> updateStatus(@PathVariable Long id, @PathVariable Integer enabled) {
        LogParseRule rule = logParseRuleMapper.selectById(id);
        if (rule == null) {
            return Result.error("解析规则不存在");
        }
        rule.setEnabled(enabled);
        logParseRuleMapper.updateById(rule);
        return Result.success("更新成功", null);
    }
}

